pub(crate) mod llicense;

use tokio::time::{timeout, Duration};
use crate::{lipo_info, ltools};
use crate::lexpose;



pub async fn test() {

    //  //////////////////////////   NTP 对时
    // let manager = NTPManager {
    //     // addr: "time.cloud.tencent.com;ntp.aliyun.com;time.edu.cn;time.apple.com;time.google.com".to_string(),
    //     addr: "time.cloud.tencent.com:98;ntp.aliyun.com:98;time.edu.cn:221;time.apple.com:98;time.google.com".to_string(),
    //     timeout: 2,
    //     loop_count: 3,
    // };
    //
    // build_ntp_async(&manager);

   println!("校验license结果： {}", llicense::verfiy_license(r"D:\IT\license.sign"));

}

pub fn test_sync() {

    //  //////////////////////////   NTP 对时
    // let manager = NTPManager {
    //     // addr: "time.cloud.tencent.com;ntp.aliyun.com;time.edu.cn;time.apple.com;time.google.com".to_string(),
    //     addr: "time.cloud.tencent.com:98;ntp.aliyun.com:98;time.edu.cn:221;time.apple.com:98;time.google.com".to_string(),
    //     timeout: 2,
    //     loop_count: 3,
    // };
    //
    // build_ntp_async(&manager);
    lipo_info!(format!("校验license结果： {}", llicense::verfiy_license(r"D:\IT\license.sign")));

}


pub(crate) struct NTPManager {
    addr: String, // 地址
    timeout: u64, // 超时时间
    loop_count: u32, // 轮询次数
}

impl NTPManager {}


/* 发起ntp对时 */
 fn build_ntp_async(param: &NTPManager) {
    let ptimeout = param.timeout;
    let ploop_count = param.loop_count;
    let adr_list: Vec<String> = param.addr.split(";").map(|s| s.to_string()).collect();
    let len = adr_list.len();
    println!("开始 build_ntp_async");

    tokio::spawn(async move {
        println!("开始 build_ntp_async tokio::spawn");

        'outer: for i in 0..ploop_count {
            /* 添加一个 任务管理器 */
            let mut join_set = tokio::task::JoinSet::new();
            /* 解析ntp 地址，并循环创建 task 任务 */
            for adr in &adr_list {
                /* 没有完全理解，大概意思是 List被循环使用，不能让里面的数据被消耗掉  还有 ptimeout 的借用，还是不太理解 */
                /* 没有完全理解，大概意思是 List被循环使用，不能让里面的数据被消耗掉  还有 ptimeout 的借用，还是不太理解 */
                /* 没有完全理解，大概意思是 List被循环使用，不能让里面的数据被消耗掉  还有 ptimeout 的借用，还是不太理解 */
                let adr01 = adr.clone();

                join_set.spawn(async move {
                    /* 构建超时， 返回结果， 超时 some(0)  */
                    match  timeout(Duration::from_secs(ptimeout), async  {
                        ltools::lntp::start_ntp(&adr01.as_str()).await
                    }).await{
                        Ok(res) =>{
                            res
                        },
                        Err(_) => {
                            lexpose::print_info_log(format!("ntp对时：{} 加载超时", &adr01));
                            Some(0)
                        }
                    }
                });
            }

            /* tag 标注任务，1成功，2全部失败， 0表示超时*/
            let mut tag = 0;
            /* 统计失败的个数 */
            let mut temp:usize = 0;
            /* 循环接收数据 */
            'inner: loop {
                match join_set.join_next().await {
                    Some(Ok(res) )=> {
                        match res {
                            Some(0) => {
                                // 超时
                            },
                            Some(_space) =>{
                                // 成功了
                                lexpose::print_info_log("ntp对时： 成功".to_string());
                                tag = 1;
                                join_set.abort_all();
                                break 'inner;
                            },
                            None => {
                                // 失败了
                                temp += 1;
                                if temp == len {
                                    lexpose::print_info_log("ntp对时： 全部失败了".to_string());
                                    tag = 2;
                                    break 'inner;
                                }
                            }
                        }
                    },
                    Some(Err(_)) => {
                        println!("结果：失败");
                        break 'inner;
                    }
                    None => {
                        println!("结束了。");
                        break 'inner;
                    }
                }
            }
            lexpose::print_info_log(format!("ntp 对时，第 {} 轮结束",(i+1)));

            /* 超时了继续循环 */
            if tag > 0 {
                break 'outer;
            }
        }

        println!("请求结束");
    });
     println!("结束 build_ntp_async");
}




